package bancosys.tec.persist.validator;

import java.util.List;

import bancosys.tec.persist.Persistable;
import bancosys.tec.persist.authorization.Authorizable;

/**
 * @created Feb 6, 2007
 * @author Gustavo Almeida
 * @deprecated Utilize validators registráveis, extender {@link AbstractValidator}
 */
@Deprecated
public abstract class AbstractBeanValidator extends DefaultBeanValidator {

    /**
     * Validações específicas do bean para inserção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public abstract List<ValidationError> customInsertValidation(Persistable bean);

    /**
     * Validações específicas do bean para remoção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public abstract List<ValidationError> customRemoveValidation(Persistable bean);

    /**
     * Validações específicas do bean para updade.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public abstract List<ValidationError> customUpdateValidation(Persistable bean);

    /**
     * Validações específicas do bean para autorizacao da inserção, a implementação padrão executa as mesmas validações da inserção. (bean
     * sendo salvo na base FRIA)
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public List<ValidationError> customInsertAuthorizationValidation(Persistable bean) {
        return this.customInsertValidation(bean);
    }

    /**
     * Valida autorizacao do insert.
     * 
     * @param bean bean.
     * @return erros ou null.
     * @deprecated utilizar customInsertAuthorizationValidation(Persistable)
     */
    @Deprecated
    public List<ValidationError> customInsertAuthorizationValidation(Authorizable bean) {
        return this.customInsertAuthorizationValidation((Persistable) bean);
    }

    /**
     * Validações específicas do bean para autorizacao da remoção, a implementação padrão executa as mesmas validações da remoção. (bean
     * sendo salvo na base FRIA)
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public List<ValidationError> customRemoveAuthorizationValidation(Persistable bean) {
        return this.customRemoveValidation(bean);
    }

    /**
     * Valida autorizacao da remoção
     * 
     * @param bean bean.
     * @return erros ou null.
     * @deprecated utilizar customRemoveAuthorizationValidation(Persistable)
     */
    @Deprecated
    public List<ValidationError> customRemoveAuthorizationValidation(Authorizable bean) {
        return this.customRemoveAuthorizationValidation((Persistable) bean);
    }

    /**
     * Validações específicas do bean para autorizacao do updade, a implementação padrão executa as mesmas validações da atualização. (bean
     * sendo salvo na base FRIA)
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    public List<ValidationError> customUpdateAuthorizationValidation(Persistable bean) {
        return this.customUpdateValidation(bean);
    }

    /**
     * Valida autorizacao da atualização
     * 
     * @param bean bean.
     * @return erros ou null.
     * @deprecated utilizar customUpdateAuthorizationValidation(Persistable)
     */
    @Deprecated
    public List<ValidationError> customUpdateAuthorizationValidation(Authorizable bean) {
        return this.customUpdateAuthorizationValidation((Persistable) bean);
    }

    /**
     * Validações de inserção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateInsert(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantPersistNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateFields(bean);
            if (defaultErrors != null && !defaultErrors.isEmpty()) {
                return defaultErrors;
            }

            defaultErrors = super.validateInsert(bean);

            List<ValidationError> customErrors = this.customInsertValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }

    /**
     * Validações de remoção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateRemove(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantRemoveNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateRemove(bean);
            List<ValidationError> customErrors = this.customRemoveValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }

    /**
     * Validações de update.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateUpdate(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantUpdateNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateFields(bean);
            if (defaultErrors != null && !defaultErrors.isEmpty()) {
                return defaultErrors;
            }

            defaultErrors = super.validateUpdate(bean);
            List<ValidationError> customErrors = this.customUpdateValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }

    /**
     * Validações de autorizacao de inserção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateInsertAuthorization(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantInsertNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateFields(bean);
            if (defaultErrors != null && !defaultErrors.isEmpty()) {
                return defaultErrors;
            }

            defaultErrors = super.validateInsertAuthorization(bean);
            List<ValidationError> customErrors = this.customInsertAuthorizationValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }

    /**
     * Validações de autorizacao de remoção.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateRemoveAuthorization(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantRemoveNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateRemoveAuthorization(bean);
            List<ValidationError> customErrors = this.customRemoveAuthorizationValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }

    /**
     * Validações de autorizacao de update.
     * 
     * @param bean bean.
     * @return lista de erros ou <code>null</code> se não houver erros.
     */
    @Override
    public List<ValidationError> validateUpdateAuthorization(Persistable bean) {
        if (bean == null) {
            List<ValidationError> errors = null;
            errors = this.addError(errors, new ValidationError("persist.validationError.cantUpdateNull", "null"));
            return errors;
        } else {
            List<ValidationError> defaultErrors = super.validateFields(bean);
            if (defaultErrors != null && !defaultErrors.isEmpty()) {
                return defaultErrors;
            }

            defaultErrors = super.validateUpdateAuthorization(bean);
            List<ValidationError> customErrors = this.customUpdateAuthorizationValidation(bean);
            return this.sumErrors(defaultErrors, customErrors);
        }
    }
}
